home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-desktop-9.10-i386-PL.iso / casper / filesystem.squashfs / usr / share / pyshared / DistUpgrade / DistUpgradeQuirks.py < prev    next >
Text File  |  2009-11-02  |  47KB  |  978 lines
  1. # DistUpgradeQuirks.py 
  2. #  
  3. #  Copyright (c) 2004-2008 Canonical
  4. #  
  5. #  Author: Michael Vogt <michael.vogt@ubuntu.com>
  6. # 
  7. #  This program is free software; you can redistribute it and/or 
  8. #  modify it under the terms of the GNU General Public License as 
  9. #  published by the Free Software Foundation; either version 2 of the
  10. #  License, or (at your option) any later version.
  11. # 
  12. #  This program is distributed in the hope that it will be useful,
  13. #  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. #  GNU General Public License for more details.
  16. # 
  17. #  You should have received a copy of the GNU General Public License
  18. #  along with this program; if not, write to the Free Software
  19. #  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  20. #  USA
  21.  
  22. import glob
  23. import logging
  24. import os
  25. import os.path
  26. import re
  27. import shutil
  28. import string
  29. import sys
  30. import subprocess
  31. from subprocess import PIPE, Popen, call
  32. from hashlib import md5
  33. from utils import lsmod
  34.  
  35. from DistUpgradeGettext import gettext as _
  36. from DistUpgradeGettext import ngettext
  37. import gettext
  38.  
  39. from computerjanitor.plugin import PluginManager
  40.  
  41. class DistUpgradeQuirks(object):
  42.     """
  43.     This class collects the various quirks handlers that can
  44.     be hooked into to fix/work around issues that the individual
  45.     releases have
  46.     """
  47.     
  48.     def __init__(self, controller, config):
  49.         self.controller = controller
  50.         self._view = controller._view
  51.         self.config = config
  52.         self.uname = Popen(["uname","-r"],stdout=PIPE).communicate()[0].strip()
  53.         self.arch = Popen(["dpkg", "--print-architecture"], stdout=PIPE).communicate()[0]
  54.         self.plugin_manager = PluginManager(self.controller, ["./plugins"])
  55.  
  56.     # the quirk function have the name:
  57.     #  $Name (e.g. PostUpgrade)
  58.     #  $todist$Name (e.g. intrepidPostUpgrade)
  59.     #  $from_$fromdist$Name (e.g. from_dapperPostUpgrade)
  60.     def run(self, quirksName):
  61.         """
  62.         Run the specific quirks handler, the follow handlers are supported:
  63.         - PostInitialUpdate: run *before* the sources.list is rewritten but
  64.                              after a initial apt-get update
  65.         - PostDistUpgradeCache: run *after* the dist-upgrade was calculated
  66.                                 in the cache
  67.         - StartUpgrade: before the first package gets installed (but the
  68.                         download is finished)
  69.         - PostUpgrade: run *after* the upgrade is finished successfully and 
  70.                        packages got installed
  71.         - PostCleanup: run *after* the cleanup (orphaned etc) is finished
  72.         """
  73.         # we do not run any quirks in partialUpgrade mode
  74.         if self.controller._partialUpgrade:
  75.             logging.info("not running quirks in partialUpgrade mode")
  76.             return
  77.         # first check for matching plugins
  78.         for condition in [
  79.             quirksName,
  80.             "%s%s" %  (self.config.get("Sources","To"), quirksName),
  81.             "from_%s%s" % (self.config.get("Sources","From"), quirksName)
  82.             ]:
  83.             for plugin in self.plugin_manager.get_plugins(condition):
  84.                 logging.debug("running quirks plugin %s" % plugin)
  85.                 plugin.do_cleanup_cruft()
  86.         
  87.         # run the handler that is common to all dists
  88.         funcname = "%s" % quirksName
  89.         func = getattr(self, funcname, None)
  90.         if func is not None:
  91.             logging.debug("quirks: running %s" % funcname)
  92.             func()
  93.  
  94.         # run the quirksHandler to-dist
  95.         funcname = "%s%s" % (self.config.get("Sources","To"), quirksName)
  96.         func = getattr(self, funcname, None)
  97.         if func is not None:
  98.             logging.debug("quirks: running %s" % funcname)
  99.             func()
  100.  
  101.         # now run the quirksHandler from_${FROM-DIST}Quirks
  102.         funcname = "from_%s%s" % (self.config.get("Sources","From"), quirksName)
  103.         func = getattr(self, funcname, None)
  104.         if func is not None:
  105.             logging.debug("quirks: running %s" % funcname)
  106.             func()
  107.  
  108.     # individual quirks handler when the dpkg run is finished ---------
  109.     def PostCleanup(self):
  110.         " run after cleanup " 
  111.         logging.debug("running Quirks.PostCleanup")
  112.  
  113.     def from_dapperPostUpgrade(self):
  114.         " this works around quirks for dapper->hardy upgrades "
  115.         logging.debug("running Controller.from_dapperQuirks handler")
  116.         self._rewriteFstab()
  117.         self._checkAdminGroup()
  118.         
  119.     def intrepidPostUpgrade(self):
  120.         " this applies rules for the hardy->intrepid upgrade "
  121.     logging.debug("running Controller.intrepidQuirks handler")
  122.         self._addRelatimeToFstab()
  123.  
  124.     def gutsyPostUpgrade(self):
  125.         """ this function works around quirks in the feisty->gutsy upgrade """
  126.         logging.debug("running Controller.gutsyQuirks handler")
  127.  
  128.     def feistyPostUpgrade(self):
  129.         """ this function works around quirks in the edgy->feisty upgrade """
  130.         logging.debug("running Controller.feistyQuirks handler")
  131.         self._rewriteFstab()
  132.         self._checkAdminGroup()
  133.  
  134.     def karmicPostUpgrade(self):
  135.         """ this function works around quirks in the jaunty->karmic upgrade """
  136.         logging.debug("running Controller.karmicPostUpgrade handler")
  137.         self._ntfsFstabFixup()
  138.         self._checkLanguageSupport()
  139.  
  140.     # quirks when run when the initial apt-get update was run -------
  141.     def karmicPostInitialUpdate(self):
  142.         " quirks that are run before the upgrade to karmic "
  143.         logging.debug("running %s" %  sys._getframe().f_code.co_name)
  144.         # we switched the supported CPU arches for armel to a minimal of ARMv6.
  145.         # upgrades on systems with CPUs not matching this minimum will break
  146.         # on karmic
  147.         if self.arch == "armel":
  148.             if not self._checkArmCPU():
  149.                 res = self._view.error(_("No ARMv6 CPU"),
  150.                     _("Your system uses an ARM CPU that is older "
  151.                       "than the ARMv6 architecture. "
  152.                       "All packages in karmic were built with "
  153.                       "optimizations requiring ARMv6 as the "
  154.                       "minimal architecture. It is not possible to "
  155.                       "upgrade your system to a new Ubuntu release "
  156.                       "with this hardware."))
  157.                 self.controller.abort()
  158.         # verver test (LP: #454783), see if there is a init around
  159.         try:
  160.             os.kill(1, 0)
  161.         except:
  162.             logging.warn("no init found")
  163.             res = self._view.askYesNoQuestion(
  164.                 _("No init available"),
  165.                 _("Your system appears to be a virtualised environment "
  166.                   "without an init daemon, e.g. Linux-VServer. "
  167.                   "Ubuntu 9.10 cannot function within this type of "
  168.                   "environment, requiring an update to your virtual "
  169.                   "machine configuration first.\n\n"
  170.                   "Are you sure you want to continue?"))
  171.             if res == False:
  172.                 self.controller.abort()
  173.             self._view.processEvents()
  174.  
  175.     # fglrx is broken in intrepid (no support for xserver 1.5)
  176.     def jauntyPostInitialUpdate(self):
  177.         " quirks that are run before the upgrade to jaunty "
  178.         logging.debug("running %s" %  sys._getframe().f_code.co_name
  179. )
  180.         # this is to deal with the fact that support for some of the cards
  181.         # that fglrx used to support got dropped
  182.         if (self._checkVideoDriver("fglrx") and 
  183.             not self._supportInModaliases("fglrx")):
  184.              # TRANSLATORS: this string is not displayed in the 9.10 upgrade
  185.              #              (but it will be used for 8.04 -> 10.04 LTS upgrades)
  186.              res = self._view.askYesNoQuestion(_("Upgrading may reduce desktop "
  187.                                          "effects, and performance in games "
  188.                                          "and other graphically intensive "
  189.                                          "programs."),
  190.                                        _("This computer is currently using "
  191.                                          "the AMD 'fglrx' graphics driver. "
  192.                                          "No version of this driver is "
  193.                                          "available that works with your "
  194.                                          "hardware in Ubuntu "
  195.                                          "10.04.\n\nDo you want to continue?"))
  196.              if res == False:
  197.                  self.controller.abort()
  198.              # if the user wants to continue we remove the fglrx driver
  199.              # here because its no use (no support for this card)
  200.              logging.debug("remove xorg-driver-fglrx,xorg-driver-fglrx-envy,fglrx-kernel-source")
  201.              l=self.controller.config.getlist("Distro","PostUpgradePurge")
  202.              l.append("xorg-driver-fglrx")
  203.              l.append("xorg-driver-fglrx-envy")
  204.              l.append("fglrx-kernel-source")
  205.              l.append("fglrx-amdcccle")
  206.              l.append("xorg-driver-fglrx-dev")
  207.              l.append("libamdxvba1")
  208.              self.controller.config.set("Distro","PostUpgradePurge",",".join(l))
  209.  
  210.     # quirks when the cache upgrade calculation is finished
  211.     def from_dapperPostDistUpgradeCache(self):
  212.         self.hardyPostDistUpgradeCache()
  213.         self.gutsyPostDistUpgradeCache()
  214.         self.feistyPostDistUpgradeCache()
  215.         self.edgyPostDistUpgradeCache()
  216.  
  217.     def from_hardyPostDistUpgradeCache(self):
  218.         self._kernel386TransitionCheck()
  219.  
  220.     def karmicPostDistUpgradeCache(self):
  221.         """ 
  222.         this function works around quirks in the 
  223.         jaunty->karmic upgrade calculation
  224.         """
  225.         # check if "wl" module is loaded and if so, install
  226.         # bcmwl-kernel-source (this is needed for lts->lts as well)
  227.         self._checkAndInstallBroadcom()
  228.         self._dealWithLanguageSupportTransition()
  229.         self._kernel386TransitionCheck()
  230.         self._mysqlClusterCheck()
  231.  
  232.     def jauntyPostDistUpgradeCache(self):
  233.         """ 
  234.         this function works around quirks in the 
  235.         intrepid->jaunty upgrade calculation
  236.         """
  237.         logging.debug("running %s" %  sys._getframe().f_code.co_name)
  238.         # bug 332328 - make sure pidgin-libnotify is upgraded
  239.         for pkg in ["pidgin-libnotify"]:
  240.             if (self.controller.cache.has_key(pkg) and
  241.                 self.controller.cache[pkg].isInstalled and
  242.                 not self.controller.cache[pkg].markedUpgrade):
  243.                 logging.debug("forcing '%s' upgrade" % pkg)
  244.                 self.controller.cache[pkg].markUpgrade()
  245.         # deal with kipi/gwenview/kphotoalbum
  246.         for pkg in ["gwenview","digikam"]:
  247.             if (self.controller.cache.has_key(pkg) and
  248.                 self.controller.cache[pkg].isInstalled and
  249.                 not self.controller.cache[pkg].markedUpgrade):
  250.                 logging.debug("forcing libkipi '%s' upgrade" % pkg)
  251.                 if self.controller.cache.has_key("libkipi0"):
  252.                     logging.debug("removing  libkipi0)")
  253.                     self.controller.cache["libkipi0"].markDelete()
  254.                 self.controller.cache[pkg].markUpgrade()
  255.         
  256.     def intrepidPostDistUpgradeCache(self):
  257.         """ 
  258.         this function works around quirks in the 
  259.         hardy->intrepid upgrade 
  260.         """
  261.         logging.debug("running %s" %  sys._getframe().f_code.co_name)
  262.         # now check for nvidia and show a warning if needed
  263.         cache = self.controller.cache
  264.         for pkgname in ["nvidia-glx-71","nvidia-glx-96"]:
  265.             if (cache.has_key(pkgname) and 
  266.                 cache[pkgname].markedInstall and
  267.                 self._checkVideoDriver("nvidia")):
  268.                 logging.debug("found %s video driver" % pkgname)
  269.                 # TRANSLATORS: this string is not displayed in the 9.10 upgrade
  270.                 #              (but it will be used for 8.04 -> 10.04 LTS upgrades)
  271.                 res = self._view.askYesNoQuestion(_("Upgrading may reduce desktop "
  272.                                         "effects, and performance in games "
  273.                                         "and other graphically intensive "
  274.                                         "programs."),
  275.                                       _("This computer is currently using "
  276.                                         "the NVIDIA 'nvidia' "
  277.                                         "graphics driver. "
  278.                                         "No version of this driver is "
  279.                                         "available that works with your "
  280.                                         "video card in Ubuntu "
  281.                                         "10.04.\n\nDo you want to continue?"))
  282.                 if res == False:
  283.                     self.controller.abort()
  284.                 # if the user continue, do not install the broken driver
  285.                 # so that we can transiton him to the free "nv" one after
  286.                 # the upgrade
  287.                 self.controller.cache[pkgname].markKeep()
  288.         # check if we have sse
  289.         for pkgname in ["nvidia-glx-173","nvidia-glx-177"]:
  290.             if (cache.has_key(pkgname) and 
  291.                 cache[pkgname].markedInstall and
  292.                 self._checkVideoDriver("nvidia")):
  293.                 logging.debug("found %s video driver" % pkgname)
  294.                 if not self._cpuHasSSESupport():
  295.                     logging.warning("nvidia driver that needs SSE but cpu has no SSE support")
  296.                     # TRANSLATORS: this string is not displayed in the 9.10 upgrade
  297.                     #              (but it will be used for 8.04 -> 10.04 LTS upgrades)
  298.                     res = self._view.askYesNoQuestion(_("Upgrading may reduce desktop "
  299.                                         "effects, and performance in games "
  300.                                         "and other graphically intensive "
  301.                                         "programs."),
  302.                                       _("This computer is currently using "
  303.                                         "the NVIDIA 'nvidia' "
  304.                                         "graphics driver. "
  305.                                         "No version of this driver is "
  306.                                         "available that works with your "
  307.                                         "video card in Ubuntu "
  308.                                         "10.04.\n\nDo you want to continue?"))
  309.                     if res == False:
  310.                         self.controller.abort()
  311.                     # if the user continue, do not install the broken driver
  312.                     # so that we can transiton him to the free "nv" one after
  313.                     # the upgrade
  314.                     self.controller.cache[pkgname].markKeep()
  315.         # kdelibs4-dev is unhappy (#279621)
  316.         fromp = "kdelibs4-dev"
  317.         to = "kdelibs5-dev"
  318.         if (self.controller.cache.has_key(fromp) and 
  319.             self.controller.cache[fromp].isInstalled and
  320.             self.controller.cache.has_key(to)):
  321.             self.controller.cache.markInstall(to, "kdelibs4-dev -> kdelibs5-dev transition")
  322.  
  323.     def hardyPostDistUpgradeCache(self):
  324.         """ 
  325.         this function works around quirks in the 
  326.         {dapper,gutsy}->hardy upgrade 
  327.         """
  328.         logging.debug("running %s" %  sys._getframe().f_code.co_name)
  329.         # deal with gnome-translator and help apt with the breaks
  330.         if (self.controller.cache.has_key("nautilus") and
  331.             self.controller.cache["nautilus"].isInstalled and
  332.             not self.controller.cache["nautilus"].markedUpgrade):
  333.             # uninstallable and gutsy apt is unhappy about this
  334.             # breaks because it wants to upgrade it and gives up
  335.             # if it can't
  336.             for broken in ("link-monitor-applet"):
  337.                 if self.controller.cache.has_key(broken) and self.controller.cache[broken].isInstalled:
  338.                     self.controller.cache[broken].markDelete()
  339.             self.controller.cache["nautilus"].markInstall()
  340.         # evms gives problems, remove it if it is not in use
  341.         self._checkAndRemoveEvms()
  342.         # give the language-support-* packages a extra kick
  343.         # (if we have network, otherwise this will not work)
  344.         if self.config.get("Options","withNetwork") == "True":
  345.             for pkg in self.controller.cache:
  346.                 if (pkg.name.startswith("language-support-") and
  347.                     pkg.isInstalled and
  348.                     not pkg.markedUpgrade):
  349.                     self.controller.cache.markInstall(pkg.name,"extra language-support- kick")
  350.  
  351.     def gutsyPostDistUpgradeCache(self):
  352.         """ this function works around quirks in the feisty->gutsy upgrade """
  353.         logging.debug("running %s" %  sys._getframe().f_code.co_name)
  354.         # lowlatency kernel flavour vanished from feisty->gutsy
  355.         try:
  356.             (version, build, flavour) = self.uname.split("-")
  357.             if (flavour == 'lowlatency' or 
  358.                 flavour == '686' or
  359.                 flavour == 'k7'):
  360.                 kernel = "linux-image-generic"
  361.                 if not (self.controller.cache[kernel].isInstalled or self.controller.cache[kernel].markedInstall):
  362.                     logging.debug("Selecting new kernel '%s'" % kernel)
  363.                     self.controller.cache[kernel].markInstall()
  364.         except Exception, e:
  365.             logging.warning("problem while transitioning lowlatency kernel (%s)" % e)
  366.         # fix feisty->gutsy utils-linux -> nfs-common transition (LP: #141559)
  367.         try:
  368.             for line in map(string.strip, open("/proc/mounts")):
  369.                 if line == '' or line.startswith("#"):
  370.                     continue
  371.                 try:
  372.                     (device, mount_point, fstype, options, a, b) = line.split()
  373.                 except Exception, e:
  374.                     logging.error("can't parse line '%s'" % line)
  375.                     continue
  376.                 if "nfs" in fstype:
  377.                     logging.debug("found nfs mount in line '%s', marking nfs-common for install " % line)
  378.                     self.controller.cache["nfs-common"].markInstall()
  379.                     break
  380.         except Exception, e:
  381.             logging.warning("problem while transitioning util-linux -> nfs-common (%s)" % e)
  382.  
  383.     def feistyPostDistUpgradeCache(self):
  384.         """ this function works around quirks in the edgy->feisty upgrade """
  385.         logging.debug("running %s" %  sys._getframe().f_code.co_name)
  386.         # ndiswrapper changed again *sigh*
  387.         for (fr, to) in [("ndiswrapper-utils-1.8","ndiswrapper-utils-1.9")]:
  388.             if self.controller.cache.has_key(fr) and self.controller.cache.has_key(to):
  389.                 if self.controller.cache[fr].isInstalled and not self.controller.cache[to].markedInstall:
  390.                     try:
  391.                         self.controller.cache.markInstall(to,"%s->%s quirk upgrade rule" % (fr, to))
  392.                     except SystemError, e:
  393.                         logging.warning("Failed to apply %s->%s install (%s)" % (fr, to, e))
  394.             
  395.  
  396.     def edgyPostDistUpgradeCache(self):
  397.         """ this function works around quirks in the dapper->edgy upgrade """
  398.         logging.debug("running %s" %  sys._getframe().f_code.co_name)
  399.         for pkg in self.controller.cache:
  400.             # deal with the python2.4-$foo -> python-$foo transition
  401.             if (pkg.name.startswith("python2.4-") and
  402.                 pkg.isInstalled and
  403.                 not pkg.markedUpgrade):
  404.                 basepkg = "python-"+pkg.name[len("python2.4-"):]
  405.                 if (self.controller.cache.has_key(basepkg) and 
  406.                     self.controller.cache[basepkg].candidateDownloadable and
  407.                     not self.controller.cache[basepkg].markedInstall):
  408.                     try:
  409.                         self.controller.cache.markInstall(basepkg,
  410.                                          "python2.4->python upgrade rule")
  411.                     except SystemError, e:
  412.                         logging.debug("Failed to apply python2.4->python install: %s (%s)" % (basepkg, e))
  413.             # xserver-xorg-input-$foo gives us trouble during the upgrade too
  414.             if (pkg.name.startswith("xserver-xorg-input-") and
  415.                 pkg.isInstalled and
  416.                 not pkg.markedUpgrade):
  417.                 try:
  418.                     self.controller.cache.markInstall(pkg.name, "xserver-xorg-input fixup rule")
  419.                 except SystemError, e:
  420.                     logging.debug("Failed to apply fixup: %s (%s)" % (pkg.name, e))
  421.             
  422.         # deal with held-backs that are unneeded
  423.         for pkgname in ["hpijs", "bzr", "tomboy"]:
  424.             if (self.controller.cache.has_key(pkgname) and self.controller.cache[pkgname].isInstalled and
  425.                 self.controller.cache[pkgname].isUpgradable and not self.controller.cache[pkgname].markedUpgrade):
  426.                 try:
  427.                     self.controller.cache.markInstall(pkgname,"%s quirk upgrade rule" % pkgname)
  428.                 except SystemError, e:
  429.                     logging.debug("Failed to apply %s install (%s)" % (pkgname,e))
  430.         # libgl1-mesa-dri from xgl.compiz.info (and friends) breaks the
  431.     # upgrade, work around this here by downgrading the package
  432.         if self.controller.cache.has_key("libgl1-mesa-dri"):
  433.             pkg = self.controller.cache["libgl1-mesa-dri"]
  434.             # the version from the compiz repo has a "6.5.1+cvs20060824" ver
  435.             if (pkg.candidateVersion == pkg.installedVersion and
  436.                 "+cvs2006" in pkg.candidateVersion):
  437.                 for ver in pkg._pkg.VersionList:
  438.                     # the "official" edgy version has "6.5.1~20060817-0ubuntu3"
  439.                     if "~2006" in ver.VerStr:
  440.             # ensure that it is from a trusted repo
  441.             for (VerFileIter, index) in ver.FileList:
  442.                 indexfile = self.controller.cache._list.FindIndex(VerFileIter)
  443.                 if indexfile and indexfile.IsTrusted:
  444.                     logging.info("Forcing downgrade of libgl1-mesa-dri for xgl.compz.info installs")
  445.                                 self.controller.cache._depcache.SetCandidateVer(pkg._pkg, ver)
  446.                     break
  447.                                     
  448.         # deal with general if $foo is installed, install $bar
  449.         for (fr, to) in [("xserver-xorg-driver-all","xserver-xorg-video-all")]:
  450.             if self.controller.cache.has_key(fr) and self.controller.cache.has_key(to):
  451.                 if self.controller.cache[fr].isInstalled and not self.controller.cache[to].markedInstall:
  452.                     try:
  453.                         self.controller.cache.markInstall(to,"%s->%s quirk upgrade rule" % (fr, to))
  454.                     except SystemError, e:
  455.                         logging.debug("Failed to apply %s->%s install (%s)" % (fr, to, e))
  456.                     
  457.     def dapperPostDistUpgradeCache(self):
  458.         """ this function works around quirks in the breezy->dapper upgrade """
  459.         logging.debug("running %s" %  sys._getframe().f_code.co_name)
  460.         if (self.controller.cache.has_key("nvidia-glx") and self.controller.cache["nvidia-glx"].isInstalled and
  461.             self.controller.cache.has_key("nvidia-settings") and self.controller.cache["nvidia-settings"].isInstalled):
  462.             logging.debug("nvidia-settings and nvidia-glx is installed")
  463.             self.controller.cache.markRemove("nvidia-settings")
  464.             self.controller.cache.markInstall("nvidia-glx")
  465.  
  466.     def from_hardyPostDistUpgradeCache(self):
  467.         """ this function works around quirks in upgrades from hardy """
  468.         logging.debug("running %s" %  sys._getframe().f_code.co_name)
  469.         # evms got removed after hardy, warn and abort
  470.         if self._usesEvmsInMounts():
  471.             logging.error("evms in use in /etc/fstab")
  472.             self._view.error(_("evms in use"),
  473.                              _("Your system uses the 'evms' volume manager "
  474.                                "in /proc/mounts. "
  475.                                "The 'evms' software is no longer supported, "
  476.                                "please switch it off and run the upgrade "
  477.                                "again when this is done."))
  478.             self.controller.abort()
  479.         # check if a key depends of kubuntu-kde4-desktop is installed
  480.         # and transition in this case as well
  481.         deps_found = False
  482.         frompkg = "kubuntu-kde4-desktop"
  483.         topkg = "kubuntu-desktop"
  484.         if self.config.getlist(frompkg,"KeyDependencies"):
  485.             deps_found = True
  486.             for pkg in self.config.getlist(frompkg,"KeyDependencies"):
  487.                 deps_found &= (self.controller.cache.has_key(pkg) and
  488.                                self.controller.cache[pkg].isInstalled)
  489.         if deps_found:
  490.             logging.debug("transitioning %s to %s (via key depends)" % (frompkg, topkg))
  491.             self.controller.cache[topkg].markInstall()
  492.             
  493.  
  494.     # run right before the first packages get installed
  495.     def StartUpgrade(self):
  496.         self._applyPatches()
  497.         self._removeOldApportCrashes()
  498.         self._removeBadMaintainerScripts()
  499.         self._killUpdateNotifier()
  500.         self._killKBluetooth()
  501.         self._killScreensaver()
  502.         self._stopDocvertConverter()
  503.     def jauntyStartUpgrade(self):
  504.         self._createPycentralPkgRemove()
  505.         # hal/NM triggers problem, if the old (intrepid) hal gets
  506.         # triggered for a restart this causes NM to drop all connections
  507.         # because (old) hal thinks it has no devices anymore (LP: #327053)
  508.         ap = "/var/lib/dpkg/info/hal.postinst"
  509.         if os.path.exists(ap):
  510.             # intrepid md5 of hal.postinst (jaunty one is different)
  511.             # md5 jaunty 22c146857d751181cfe299a171fc11c9
  512.             md5sum = "146145275900af343d990a4dea968d7c"
  513.             if md5(open(ap).read()).hexdigest() == md5sum:
  514.                 logging.debug("removing bad script '%s'" % ap)
  515.                 os.unlink(ap)
  516.     def dapperStartUpgrade(self):
  517.         # check theme, crux is known to fail badly when upgraded 
  518.         # from dapper
  519.         if "DISPLAY" in os.environ and "SUDO_USER" in os.environ:
  520.             out = subprocess.Popen(["sudo","-u", os.environ["SUDO_USER"],
  521.                                     "./theme-switch-helper.py", "-g"],
  522.                                     stdout=subprocess.PIPE).communicate()[0]
  523.             if "Crux" in out:
  524.                 subprocess.call(["sudo","-u", os.environ["SUDO_USER"],
  525.                                     "./theme-switch-helper.py", "--defaults"])
  526.         return True
  527.     # helpers
  528.  
  529.     def _mysqlClusterCheck(self):
  530.         """
  531.         check if ndb clustering is used and do not upgrade mysql
  532.         if it is (LP: #450837)
  533.         """
  534.         logging.debug("_mysqlClusterCheck")
  535.         if (self.controller.cache.has_key("mysql-server") and
  536.             self.controller.cache["mysql-server"].isInstalled):
  537.             # taken from the mysql-server-5.1.preinst
  538.             ret = subprocess.call([
  539.                     "egrep", "-q", "-i", "-r",
  540.                     "^[^#]*ndb.connectstring|^[:space:]*\[[:space:]*ndb_mgmd", 
  541.                     "/etc/mysql/"])
  542.             logging.debug("egrep returned %s" % ret)
  543.             # if clustering is used, do not upgrade to 5.1 and 
  544.             # remove mysql-{server,client}
  545.             # metapackage and upgrade the 5.0 packages
  546.             if ret == 0:
  547.                 logging.debug("mysql clustering in use, do not upgrade to 5.1")
  548.                 for pkg in ("mysql-server", "mysql-client"):
  549.                     self.controller.cache.markRemove(pkg, "clustering in use")
  550.                     # mark mysql-{server,client}-5.0 as manual install (#453513)
  551.                     depcache = self.controller.cache._depcache
  552.                     for pkg in ["mysql-server-5.0", "mysql-client-5.0"]:
  553.                         if pkg.isInstalled and depcache.IsAutoInstalled(pkg._pkg):
  554.                             logging.debug("marking '%s' manual installed" % pkg.name)
  555.                             autoInstDeps = False
  556.                             fromUser = True
  557.                             depcache.MarkInstall(pkg._pkg, autoInstDeps, fromUser)
  558.             else:
  559.                 self.controller.cache.markUpgrade("mysql-server", "no clustering in use")
  560.  
  561.     def _checkArmCPU(self):
  562.         """
  563.         parse /proc/cpuinfo and search for ARMv6 or greater
  564.         """
  565.         logging.debug("checking for ARM CPU version")
  566.         if not os.path.exists("/proc/cpuinfo"):
  567.             logging.error("cannot open /proc/cpuinfo ?!?")
  568.             return False
  569.         cpuinfo = open("/proc/cpuinfo")
  570.         if re.search("^Processor\s*:\s*ARMv[45]", cpuinfo.read(), re.MULTILINE):
  571.             return False
  572.         return True
  573.  
  574.     def _dealWithLanguageSupportTransition(self):
  575.         """
  576.         In karmic the language-support-translations-* metapackages
  577.         are gone and the direct dependencies will get marked for
  578.         auto removal - mark them as manual instead
  579.         """
  580.         logging.debug("language-support-translations-* transition")
  581.         for pkg in self.controller.cache:
  582.             depcache = self.controller.cache._depcache
  583.             if (pkg.name.startswith("language-support-translations") and
  584.                 pkg.isInstalled):
  585.                 for dp_or in pkg.installedDependencies:
  586.                     for dpname in dp_or.or_dependencies:
  587.                         dp = self.controller.cache[dpname.name]
  588.                         if dp.isInstalled and depcache.IsAutoInstalled(dp._pkg):
  589.                             logging.debug("marking '%s' manual installed" % dp.name)
  590.                             autoInstDeps = False
  591.                             fromUser = True
  592.                             depcache.MarkInstall(dp._pkg, autoInstDeps, fromUser)
  593.                             
  594.     def _checkLanguageSupport(self):
  595.         """
  596.         check if the language support is fully installed and if
  597.         not generate a update-notifier note on next login
  598.         """
  599.         if not os.path.exists("/usr/bin/check-language-support"):
  600.             logging.debug("no check-language-support available")
  601.             return
  602.         p = subprocess.Popen(["check-language-support"],stdout=subprocess.PIPE)
  603.         for pkgname in p.communicate()[0].split():
  604.             if (self.controller.cache.has_key(pkgname) and
  605.                 not self.controller.cache[pkgname].isInstalled):
  606.                 logging.debug("language support package '%s' missing" % pkgname)
  607.                 # check if kde/gnome and copy language-selector note
  608.                 base = "/usr/share/language-support/"
  609.                 target = "/var/lib/update-notifier/user.d"
  610.                 for p in ("incomplete-language-support-gnome.note",
  611.                           "incomplete-language-support-qt.note"):
  612.                     if os.path.exists(os.path.join(base,p)):
  613.                         shutil.copy(os.path.join(base,p), target)
  614.                         return
  615.  
  616.     def _checkAndInstallBroadcom(self):
  617.         """
  618.         check for the 'wl' kernel module and install bcmwl-kernel-source
  619.         if the module is loaded
  620.         """
  621.         logging.debug("checking for 'wl' module")
  622.         if "wl" in lsmod():
  623.             self.controller.cache.markInstall("bcmwl-kernel-source",
  624.                                               "'wl' module found in lsmod")
  625.  
  626.     def _stopDocvertConverter(self):
  627.         " /etc/init.d/docvert-converter stop (see bug #450569)"
  628.         # kill update-notifier now to suppress reboot required
  629.         if os.path.exists("/etc/init.d/docvert-converter"):
  630.             logging.debug("/etc/init.d/docvert-converter stop")
  631.             subprocess.call(["/etc/init.d/docvert-converter","stop"])
  632.     def _killUpdateNotifier(self):
  633.         "kill update-notifier"
  634.         # kill update-notifier now to suppress reboot required
  635.         if os.path.exists("/usr/bin/killall"):
  636.             logging.debug("killing update-notifier")
  637.             subprocess.call(["killall","-q","update-notifier"])
  638.     def _killKBluetooth(self):
  639.         """killall kblueplugd kbluetooth (riddel requested it)"""
  640.         if os.path.exists("/usr/bin/killall"):
  641.             logging.debug("killing kblueplugd kbluetooth4")
  642.             subprocess.call(["killall", "-q", "kblueplugd", "kbluetooth4"])
  643.     def _killScreensaver(self):
  644.         """killall gnome-screensaver """
  645.         if os.path.exists("/usr/bin/killall"):
  646.             logging.debug("killing gnome-screensaver")
  647.             subprocess.call(["killall", "-q", "gnome-screensaver"])
  648.     def _removeBadMaintainerScripts(self):
  649.         " remove bad/broken maintainer scripts (last resort) "
  650.         # apache: workaround #95325 (edgy->feisty)
  651.         # pango-libthai #103384 (edgy->feisty)
  652.         bad_scripts = ["/var/lib/dpkg/info/apache2-common.prerm",
  653.                        "/var/lib/dpkg/info/pango-libthai.postrm",
  654.                        ]
  655.         for ap in bad_scripts:
  656.             if os.path.exists(ap):
  657.                 logging.debug("removing bad script '%s'" % ap)
  658.                 os.unlink(ap)
  659.  
  660.     def _createPycentralPkgRemove(self):
  661.         """
  662.         intrepid->jaunty, create /var/lib/pycentral/pkgremove flag file
  663.         to help python-central so that it removes all preinst links
  664.         on upgrade
  665.         """
  666.         logging.debug("adding pkgremove file")
  667.         if not os.path.exists("/var/lib/pycentral/"):
  668.             os.makedirs("/var/lib/pycentral")
  669.         open("/var/lib/pycentral/pkgremove","w")
  670.  
  671.     def _removeOldApportCrashes(self):
  672.         " remove old apport crash files "
  673.         try:
  674.             for f in glob.glob("/var/crash/*.crash"):
  675.                 logging.debug("removing old crash file '%s'" % f)
  676.                 os.unlink(f)
  677.         except Exception, e:
  678.             logging.warning("error during unlink of old crash files (%s)" % e)
  679.  
  680.     def _cpuHasSSESupport(self, cpuinfo="/proc/cpuinfo"):
  681.         " helper that checks if the given cpu has sse support "
  682.         if not os.path.exists(cpuinfo):
  683.             return False
  684.         for line in open(cpuinfo):
  685.             if line.startswith("flags") and not " sse" in line:
  686.                 return False
  687.         return True
  688.  
  689.     def _usesEvmsInMounts(self):
  690.         " check if evms is used in /proc/mounts "
  691.         logging.debug("running _usesEvmsInMounts")
  692.         for line in open("/proc/mounts"):
  693.             line = line.strip()
  694.             if line == '' or line.startswith("#"):
  695.                 continue
  696.             try:
  697.                 (device, mount_point, fstype, options, a, b) = line.split()
  698.             except Exception, e:
  699.                 logging.error("can't parse line '%s'" % line)
  700.                 continue
  701.             if "evms" in device:
  702.                 logging.debug("found evms device in line '%s', skipping " % line)
  703.                 return True
  704.         return False
  705.  
  706.     def _checkAndRemoveEvms(self):
  707.         " check if evms is in use and if not, remove it "
  708.         logging.debug("running _checkAndRemoveEvms")
  709.         if self._usesEvmsInMounts():
  710.             return False
  711.         # if not in use, nuke it
  712.         for pkg in ["evms","libevms-2.5","libevms-dev",
  713.                     "evms-ncurses", "evms-ha",
  714.                     "evms-bootdebug",
  715.                     "evms-gui", "evms-cli",
  716.                     "linux-patch-evms"]:
  717.             if self.controller.cache.has_key(pkg) and self.controller.cache[pkg].isInstalled:
  718.                 self.controller.cache[pkg].markDelete()
  719.         return True
  720.  
  721.     def _addRelatimeToFstab(self):
  722.         " add the relatime option to ext2/ext3 filesystems on upgrade "
  723.         logging.debug("_addRelatime")
  724.         replaced = False
  725.         lines = []
  726.         for line in open("/etc/fstab"):
  727.             line = line.strip()
  728.             if line == '' or line.startswith("#"):
  729.                 lines.append(line)
  730.                 continue
  731.             try:
  732.                 (device, mount_point, fstype, options, a, b) = line.split()
  733.             except Exception, e:
  734.                 logging.error("can't parse line '%s'" % line)
  735.                 lines.append(line)
  736.                 continue
  737.             if (("ext2" in fstype or
  738.                  "ext3" in fstype) and 
  739.                 (not "noatime" in options) and
  740.                 (not "relatime" in options) ):
  741.                 logging.debug("adding 'relatime' to line '%s' " % line)
  742.                 line = line.replace(options,"%s,relatime" % options)
  743.                 logging.debug("replaced line is '%s' " % line)
  744.                 replaced=True
  745.             lines.append(line)
  746.         # we have converted a line
  747.         if replaced:
  748.             logging.debug("writing new /etc/fstab")
  749.             f=open("/etc/fstab.intrepid","w")
  750.             f.write("\n".join(lines))
  751.             # add final newline (see LP: #279093)
  752.             f.write("\n")
  753.             f.close()
  754.             os.rename("/etc/fstab.intrepid","/etc/fstab")
  755.         return True
  756.         
  757.     def _ntfsFstabFixup(self, fstab="/etc/fstab"):
  758.         """change PASS 1 to 0 for ntfs entries (#441242)"""
  759.         logging.debug("_ntfsFstabFixup")
  760.         replaced = False
  761.         lines = []
  762.         for line in open(fstab):
  763.             line = line.strip()
  764.             if line == '' or line.startswith("#"):
  765.                 lines.append(line)
  766.                 continue
  767.             try:
  768.                 (device, mount_point, fstype, options, fdump, fpass) = line.split()
  769.             except Exception, e:
  770.                 logging.error("can't parse line '%s'" % line)
  771.                 lines.append(line)
  772.                 continue
  773.             if ("ntfs" in fstype and fpass == "1"):
  774.                 logging.debug("changing PASS for ntfs to 0 for '%s' " % line)
  775.                 if line[-1] == "1":
  776.                     line = line[:-1] + "0"
  777.                 else:
  778.                     logging.error("unexpected value in line")
  779.                 logging.debug("replaced line is '%s' " % line)
  780.                 replaced=True
  781.             lines.append(line)
  782.         # we have converted a line
  783.         if replaced:
  784.             suffix = ".jaunty"
  785.             logging.debug("writing new /etc/fstab")
  786.             f=open(fstab + suffix, "w")
  787.             f.write("\n".join(lines))
  788.             # add final newline (see LP: #279093)
  789.             f.write("\n")
  790.             f.close()
  791.             os.rename(fstab+suffix, fstab)
  792.         return True
  793.         
  794.  
  795.     def _rewriteFstab(self):
  796.         " convert /dev/{hd?,scd0} to /dev/cdrom for the feisty upgrade "
  797.         logging.debug("_rewriteFstab()")
  798.         replaced = 0
  799.         lines = []
  800.         # we have one cdrom to convert
  801.         for line in open("/etc/fstab"):
  802.             line = line.strip()
  803.             if line == '' or line.startswith("#"):
  804.                 lines.append(line)
  805.                 continue
  806.             try:
  807.                 (device, mount_point, fstype, options, a, b) = line.split()
  808.             except Exception, e:
  809.                 logging.error("can't parse line '%s'" % line)
  810.                 lines.append(line)
  811.                 continue
  812.             # edgy kernel has /dev/cdrom -> /dev/hd?
  813.             # feisty kernel (for a lot of chipsets) /dev/cdrom -> /dev/scd0
  814.             # this breaks static mounting (LP#86424)
  815.             #
  816.             # we convert here to /dev/cdrom only if current /dev/cdrom
  817.             # points to the device in /etc/fstab already. this ensures
  818.             # that we don't break anything or that we get it wrong
  819.             # for systems with two (or more) cdroms. this is ok, because
  820.             # we convert under the old kernel
  821.             if ("iso9660" in fstype and
  822.                 device != "/dev/cdrom" and
  823.                 os.path.exists("/dev/cdrom") and
  824.                 os.path.realpath("/dev/cdrom") == device
  825.                 ):
  826.                 logging.debug("replacing '%s' " % line)
  827.                 line = line.replace(device,"/dev/cdrom")
  828.                 logging.debug("replaced line is '%s' " % line)
  829.                 replaced += 1
  830.             lines.append(line)
  831.         # we have converted a line (otherwise we would have exited already)
  832.         if replaced > 0:
  833.             logging.debug("writing new /etc/fstab")
  834.             shutil.copy("/etc/fstab","/etc/fstab.edgy")
  835.             f=open("/etc/fstab","w")
  836.             f.write("\n".join(lines))
  837.             # add final newline (see LP: #279093)
  838.             f.write("\n")
  839.             f.close()
  840.         return True
  841.  
  842.     def _checkAdminGroup(self):
  843.         " check if the current sudo user is in the admin group "
  844.         logging.debug("_checkAdminGroup")
  845.         import grp
  846.         try:
  847.             admin_group = grp.getgrnam("admin").gr_mem
  848.         except KeyError, e:
  849.             logging.warning("System has no admin group (%s)" % e)
  850.             subprocess.call(["addgroup","--system","admin"])
  851.         # double paranoia
  852.         try:
  853.             admin_group = grp.getgrnam("admin").gr_mem
  854.         except KeyError, e:
  855.             logging.warning("adding the admin group failed (%s)" % e)
  856.             return
  857.         # if the current SUDO_USER is not in the admin group
  858.         # we add him - this is no security issue because
  859.         # the user is already root so adding him to the admin group
  860.         # does not change anything
  861.         if (os.environ.has_key("SUDO_USER") and
  862.             not os.environ["SUDO_USER"] in admin_group):
  863.             admin_user = os.environ["SUDO_USER"]
  864.             logging.info("SUDO_USER=%s is not in admin group" % admin_user)
  865.             cmd = ["usermod","-a","-G","admin",admin_user]
  866.             res = subprocess.call(cmd)
  867.             logging.debug("cmd: %s returned %i" % (cmd, res))
  868.  
  869.     def _checkVideoDriver(self, name):
  870.         " check if the given driver is in use in xorg.conf "
  871.         XORG="/etc/X11/xorg.conf"
  872.         if not os.path.exists(XORG):
  873.             return False
  874.         for line in open(XORG):
  875.             s=line.split("#")[0].strip()
  876.             # check for fglrx driver entry
  877.             if (s.lower().startswith("driver") and
  878.                 s.endswith('"%s"' % name)):
  879.                 return True
  880.         return False
  881.  
  882.     def _applyPatches(self, patchdir="./patches"):
  883.         """
  884.         helper that applies the patches in patchdir. the format is
  885.         _path_to_file.md5sum
  886.         
  887.         and it will apply the diff to that file if the md5sum
  888.         matches
  889.         """
  890.         if not os.path.exists(patchdir):
  891.             logging.debug("no patchdir")
  892.             return
  893.         if not ("PATH" in os.environ and
  894.                 [p for p in os.environ["PATH"].split(":")
  895.                  if os.path.exists(os.path.join(p,"sed"))]):
  896.             logging.debug("no binary 'sed' found in PATH")
  897.             return
  898.         for f in os.listdir(patchdir):
  899.             # skip, not a patch file, they all end with .$md5sum
  900.             if not "." in f:
  901.                 logging.debug("skipping '%s' (no '.')" % f)
  902.                 continue
  903.             logging.debug("check if patch '%s' needs to be applied" % f)
  904.             (encoded_path, md5sum) = string.rsplit(f, ".", 1)
  905.             # FIXME: this is not clever and needs quoting support for
  906.             #        filenames with "_" in the name
  907.             path = encoded_path.replace("_","/")
  908.             #logging.debug("target for '%s' is '%s' -> '%s'" % (
  909.             #        f, encoded_path, path))
  910.             if (os.path.exists(path) and
  911.                 md5(open(path).read()).hexdigest() == md5sum):
  912.                 logging.info("applying '%s'" % f)
  913.                 # dry-run first, then patch if ok
  914.                 cmd = ["sed","-n", "-f", patchdir+"/"+f, path]
  915.                 logging.debug("runing '%s'" % cmd)
  916.                 res = call(cmd)
  917.                 if res == 0:
  918.                     res = call(["sed","-i","-f", patchdir+"/"+f, path])
  919.                     logging.info("applied '%s' with %i status" % (f,res))
  920.                 else:
  921.                     logging.warning("dry run failed, ignoring patch '%s'" % f)
  922.                     
  923.     def _supportInModaliases(self, xorgdrivername, modaliasesdir="./modaliases", lspci=None):
  924.         """ 
  925.         Check if xorgdriver will work on this hardware
  926.  
  927.         This helper will check with the modaliasesdir if the given 
  928.         xorgdriver will work on this hardware (or the hardware given
  929.         via the lspci argument)
  930.         """
  931.         if not lspci:
  932.             lspci = set()
  933.             p = subprocess.Popen(["lspci","-n"],stdout=subprocess.PIPE)
  934.             for line in p.communicate()[0].split("\n"):
  935.                 if line:
  936.                     lspci.add(line.split()[2])
  937.         for filename in os.listdir(modaliasesdir):
  938.             #logging.debug("modalias file '%s'" % filename)
  939.             for line in open(os.path.join(modaliasesdir,filename)):
  940.                 line = line.strip()
  941.                 if line == "" or line.startswith("#"):
  942.                     continue
  943.                 (key, pciid, xorgdriver, pkgname) = line.split()
  944.                 if xorgdriver != xorgdrivername:
  945.                     continue
  946.                 m = re.match("pci:v0000(.+)d0000(.+)sv.*", pciid)
  947.                 if m:
  948.                     matchid = "%s:%s" % (m.group(1), m.group(2))
  949.                     if matchid.lower() in lspci:
  950.                         logging.debug("found system pciid '%s' in modaliases" % matchid)
  951.                         return True
  952.         logging.debug("checking for %s support in modaliases but none found" % xorgdrivername)
  953.         return False
  954.                     
  955.  
  956.     def _kernel386TransitionCheck(self):
  957.         """ test if the current kernel is 386 and if the system is 
  958.             capable of using a generic one instead (#353534)
  959.         """
  960.         logging.debug("_kernel386TransitionCheck")
  961.         # we test first if one of 386 is installed
  962.         # if so, check if the system could also work with -generic
  963.         # (we get that from base-installer) and try to installed
  964.         #  that)
  965.         for pkgname in ["linux-386", "linux-image-386"]:
  966.             if (self.controller.cache.has_key(pkgname) and
  967.                 self.controller.cache[pkgname].isInstalled):
  968.                 working_kernels = self.controller.cache.getKernelsFromBaseInstaller()
  969.                 upgrade_to = ["linux-generic", "linux-image-generic"]
  970.                 for pkgname in upgrade_to:
  971.                     if pkgname in working_kernels:
  972.                         logging.debug("386 kernel installed, but generic kernel  will work on this machine")
  973.                         if self.controller.cache.markInstall(pkgname, "386 -> generic transition"):
  974.                             return
  975.         
  976.  
  977.  
  978.